Design is hard work and focusing on solving user and customer problems is the crux of that work. If you can find a tool that keeps that focus whilst eliminating some of the hard work then it’s clearly advantageous to use that tool. That’s where design patterns come in. They save designers from having to reinvent the wheel in their design efforts and allow them to keep focus on solving problems instead.
What is a Design Pattern?
A design pattern is simply a reusable idea, design or code structure that has already been optimized for the purpose it is intended for. It is a very common approach in software design and development (though the approach for a software design pattern must be language agnostic and thus implementable on any development project) and in more visual design approaches too (such as UI design or help screen design).
Petrula Vrontikis, the leading designer and design educator says; “Practice safe design: use a concept.” Design patterns are concepts which have been fully fleshed out and are applicable to more than one project.
An example of the use of design patterns in software engineering.
© Aaron Rotenberg, Public Domain
What Goes Into a Design Pattern?
How long is a piece of string? It’s one of those questions. Design patterns can be used for so many different applications that there’s no standard for developing a design pattern. In general, the best design patterns act as guides to implementation in any circumstance that the concept may be needed in. That means that software patterns should not be based on code but rather on principles which can be implemented in any language. Graphic design patterns should be detailed enough that they can be quickly adapted to another project but not so detailed that they constrain rapid adaption. Learning design patterns should be high-level enough that they can be moved from a course on software development to a course on leadership without endless reiteration and so on….
There are no hard and fast rules for design patterns, but to be useful they are often compiled into pattern libraries like this one.
© Unknown, Unknown
Creating Design Patterns
While there are no hard and fast rules for what goes into a design pattern – if you are going to create design patterns within your business you should:
Define what the design pattern is to be used for and clearly label that use on the pattern
Ensure that you version control design patterns so that latest revisions of a pattern are always preferred to earlier versions
Store design patterns somewhere that they can easily be accessed by all relevant parties – that means either in a physical location which can be accessed by all or in a server location that can be accessed by everyone – design patterns are of no value if they cannot be gotten to when they are needed
Regularly review design patterns for their utility – are they still a solution to a regularly occurring problem or can they be ditched? For example if you’ve made the move to social media logins for apps and websites – old school registration forms might need to be removed from your design pattern library.
Design patterns can have many uses. Here’s an abstract of a factory’s design pattern.
© Giacomo Ritucci, CC BY-SA 3.0
The Advantages of Design Patterns
Design patterns are useful in terms of:
Saving time – a pre-built solution to a regularly occurring problem means that there’s no need to reinvent the wheel, you can pull the solution off the shelf and implement it
Saving money – when you save time, you also save money in a corporate environment
You may also find that you can source design patterns (for free or at a small cost) from other organizations or online. This can reduce the effort required to create the patterns themselves.
The Disadvantages of Design Patterns
Design patterns may also cause issues when their use is not carefully considered including:
They prevent proper consideration of a problem. Sometimes a problem is not what it appears to be – reaching for a pre-built solution to the wrong problem can add time and cost more money to design and development lifecycles.
They may be irrelevant in certain circumstances. Software design patterns, in particular, may be irrelevant if the style of programming language is different to the previous style that the pattern was developed for. There are many different ways of handling things in different software languages and even when a language agnostic approach is employed; it can be difficult to capture these differences meaningfully in a pattern.
They may introduce inefficiency into the final product or solution. What was the best solution last year is not guaranteed to be the best solution this year. Even if the pattern still solves the problem – it may not solve it in the best way possible.
They require management. In order to be useful design patterns need to be created carefully (which costs time and money) and stored in a way so that they are accessible to everyone who needs them. In addition you may need to educate people on the use and creation of these patterns.
An example of a simple UI design pattern–these can rapidly become much more complex and valuable as needed.
© RegisFrey, Public Domain
The Take Away
Design patterns offer an “off the shelf” approach to solving recurring problems in design. They can be very effective in terms of saving time and money on design projects. On the flip side, if their use is not carefully considered they can actually impede the delivery of high quality design projects. It is important that if patterns are to be used that they are created carefully for reuse and that they can be accessed by anyone who needs them easily.
Resources
Wanting to create some software design patterns? Here’s a good walkthrough for you - http://code.tutsplus.com/articles/a-beginners-guide-to-design-patterns--net-12752
You can find some excellent examples of UI design patterns here - https://www.smashingmagazine.com/2009/06/10-ui-design-patterns-you-should-be-paying-attention-to/
